Scrolling a web page is an important browser automation operation in Selenium WebDriver. Modern websites often contain long pages, dynamic sections, product listings, forms, tables, dashboards, footer sections, and lazy-loaded content that may not be visible in the current browser viewport. Selenium automation may therefore need to scroll the page before interacting with or validating specific elements.
In Selenium with Java, page scrolling can be handled using Selenium's Actions API or JavaScriptExecutor. JavaScriptExecutor is especially useful when the automation script needs precise control over the browser's scroll position or needs to scroll directly to a particular WebElement.
Course Resource: Selenium Training Course | Register for Course Demo
Scroll Page in Selenium means moving the browser viewport vertically or horizontally so that content outside the currently visible area becomes accessible.
For example, if a Submit button is located at the bottom of a long registration page, Selenium may need to scroll the page until the button is visible before performing an action.
Open Web Page
↓
Locate Target Element
↓
Check Current Viewport
↓
Scroll Page
↓
Target Becomes Visible
↓
Perform Action
↓
Validate Result
Scrolling is useful whenever the target content is outside the current viewport or when scrolling itself triggers additional application behavior.
There are several approaches to scrolling in Selenium.
| Technique | Purpose |
|---|---|
| JavaScriptExecutor | Programmatically control browser scrolling |
| Actions.scrollByAmount() | Scroll by a specific amount |
| Actions.scrollToElement() | Scroll directly to an element |
| scrollIntoView() | Bring a particular DOM element into the viewport |
| Container scroll | Scroll an internal div or panel |
| Keyboard actions | Use PAGE_DOWN, PAGE_UP, HOME and END |
JavascriptExecutor is a Selenium interface that allows Java Selenium programs to execute JavaScript inside the browser's current page context.
It is commonly used for specialized browser operations such as scrolling, reading page properties, interacting with DOM properties, checking page readiness, highlighting elements, and performing other JavaScript-based operations.
import org.openqa.selenium.JavascriptExecutor;JavascriptExecutor js = (JavascriptExecutor) driver;The WebDriver object is type-cast to JavascriptExecutor so JavaScript can be executed through Selenium.
The window.scrollBy() method can be used to move the browser viewport by a specified number of pixels.
JavascriptExecutor js = (JavascriptExecutor) driver;
js.executeScript("window.scrollBy(0,500);");
Here, 0 represents horizontal movement and 500 represents vertical movement.
js.executeScript("window.scrollBy(0,1000);");This moves the page approximately 1000 pixels downward.
A negative vertical value can be used to scroll upward.
js.executeScript("window.scrollBy(0,-500);");Horizontal scrolling can be performed by changing the first value.
js.executeScript("window.scrollBy(500,0);");The window.scrollTo() method can move the page directly to a specific coordinate.
js.executeScript("window.scrollTo(0,0);");js.executeScript(
"window.scrollTo(0, document.body.scrollHeight);"
);
document.body.scrollHeight represents the total height of the page content.
| Method | Meaning | Example |
|---|---|---|
| scrollBy() | Moves relative to the current position | window.scrollBy(0,500) |
| scrollTo() | Moves to an absolute position | window.scrollTo(0,1000) |
Instead of guessing the number of pixels, Selenium can scroll directly to a target element.
WebElement element = driver.findElement(By.id("footer"));
JavascriptExecutor js = (JavascriptExecutor) driver;
js.executeScript(
"arguments[0].scrollIntoView(true);",
element
);
The JavaScript scrollIntoView() method scrolls the page until the specified DOM element is visible in the viewport.
arguments[0].scrollIntoView(true);When the element is passed as an argument from Selenium, it becomes arguments[0] inside the JavaScript code.
arguments[0] represents the first argument supplied to JavaScriptExecutor.
WebElement button = driver.findElement(By.id("submit"));
js.executeScript(
"arguments[0].scrollIntoView(true);",
button
);
Here, button is passed as the first argument and becomes arguments[0].
Centering an element can be useful on pages with sticky headers or fixed navigation bars.
WebElement element = driver.findElement(By.id("submit"));
js.executeScript(
"arguments[0].scrollIntoView({block:'center'});",
element
);
js.executeScript(
"arguments[0].scrollIntoView({block:'start'});",
element
);
js.executeScript(
"arguments[0].scrollIntoView({block:'end'});",
element
);
js.executeScript(
"arguments[0].scrollIntoView({block:'nearest'});",
element
);
The nearest option attempts to move the minimum amount necessary to make the element visible.
js.executeScript(
"arguments[0].scrollIntoView({block:'center', inline:'center'});",
element
);
Selenium's Actions class provides scrolling capabilities through WebDriver input actions.
Actions actions = new Actions(driver);
actions.scrollByAmount(0, 500).perform();
import org.openqa.selenium.interactions.Actions;WebElement element = driver.findElement(By.id("target"));
Actions actions = new Actions(driver);
actions.scrollToElement(element).perform();
| Feature | JavaScriptExecutor | Actions |
|---|---|---|
| Pixel scrolling | Yes | Yes |
| Scroll to element | scrollIntoView() | scrollToElement() |
| DOM JavaScript execution | Yes | No |
| Browser-side scripting | Yes | No |
| Input action model | Not its main purpose | Yes |
Keyboard keys can also be used for page navigation.
Actions actions = new Actions(driver);
actions.sendKeys(Keys.PAGE_DOWN).perform();
actions.sendKeys(Keys.PAGE_UP).perform();actions.sendKeys(Keys.HOME).perform();actions.sendKeys(Keys.END).perform();| Key | Typical Purpose |
|---|---|
| PAGE_DOWN | Move viewport downward |
| PAGE_UP | Move viewport upward |
| HOME | Move toward the beginning |
| END | Move toward the end |
A common Selenium scenario is scrolling an element into view before clicking it.
WebElement button = driver.findElement(By.id("submit"));
js.executeScript(
"arguments[0].scrollIntoView({block:'center'});",
button
);
button.click();
WebElement address = driver.findElement(By.id("address"));
js.executeScript(
"arguments[0].scrollIntoView({block:'center'});",
address
);
address.sendKeys("Mumbai");
WebElement country = driver.findElement(By.id("country"));
js.executeScript(
"arguments[0].scrollIntoView({block:'center'});",
country
);
Select select = new Select(country);
select.selectByVisibleText("India");
WebElement checkbox = driver.findElement(By.id("terms"));
js.executeScript(
"arguments[0].scrollIntoView({block:'center'});",
checkbox
);
if (!checkbox.isSelected()) {
checkbox.click();
}
WebElement radio = driver.findElement(By.id("male"));
js.executeScript(
"arguments[0].scrollIntoView({block:'center'});",
radio
);
radio.click();
Scrolling can be used to position a specific page section before capturing evidence.
WebElement section = driver.findElement(By.id("pricing"));
js.executeScript(
"arguments[0].scrollIntoView({block:'center'});",
section
);
File screenshot = ((TakesScreenshot) driver)
.getScreenshotAs(OutputType.FILE);
WebElement footer = driver.findElement(
By.tagName("footer")
);
js.executeScript(
"arguments[0].scrollIntoView({block:'center'});",
footer
);
WebElement table = driver.findElement(
By.id("employeeTable")
);
js.executeScript(
"arguments[0].scrollIntoView({block:'center'});",
table
);
WebElement form = driver.findElement(
By.id("registrationForm")
);
js.executeScript(
"arguments[0].scrollIntoView({block:'center'});",
form
);
WebElement link = driver.findElement(
By.linkText("Contact Us")
);
js.executeScript(
"arguments[0].scrollIntoView({block:'center'});",
link
);
WebElement product = driver.findElement(
By.xpath("//h2[text()='Laptop']")
);
js.executeScript(
"arguments[0].scrollIntoView({block:'center'});",
product
);
E-commerce applications often contain long product pages and product listings. Automation may need to scroll to product details, reviews, recommendations, related products, filters, or checkout controls.
WebElement reviews = driver.findElement(
By.id("customer-reviews")
);
js.executeScript(
"arguments[0].scrollIntoView({block:'center'});",
reviews
);
Assert.assertTrue(reviews.isDisplayed());
Long registration forms may contain address, employment, preferences, terms, and submission sections below the initial viewport.
WebElement address = driver.findElement(By.id("address"));
js.executeScript(
"arguments[0].scrollIntoView({block:'center'});",
address
);
address.sendKeys("Mumbai");
WebElement placeOrder = driver.findElement(
By.id("place-order")
);
js.executeScript(
"arguments[0].scrollIntoView({block:'center'});",
placeOrder
);
placeOrder.click();
Scrolling does not replace synchronization. A page may continue loading even after the browser has navigated to it. Explicit waits should be used when the target element depends on dynamic application behavior.
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement element = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("target")
)
);
js.executeScript(
"arguments[0].scrollIntoView({block:'center'});",
element
);
WebDriverWait wait = new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement button = wait.until(
ExpectedConditions.elementToBeClickable(
By.id("submit")
)
);
js.executeScript(
"arguments[0].scrollIntoView({block:'center'});",
button
);
button.click();
Many modern websites use sticky navigation bars that remain fixed at the top of the browser while the page scrolls. A target element can therefore become technically visible but still be covered by the fixed header.
js.executeScript(
"arguments[0].scrollIntoView(true);",
element
);
js.executeScript("window.scrollBy(0,-100);");
The offset should be adjusted according to the actual fixed header used by the application.
js.executeScript(
"arguments[0].scrollIntoView({block:'center'});",
element
);
Centering the element can make it easier to interact with when the top of the viewport contains fixed navigation.
Not every scroll operation affects the entire browser window. Many applications contain scrollable panels, lists, modals, sidebars, or table containers.
WebElement container = driver.findElement(
By.id("scrollContainer")
);
js.executeScript(
"arguments[0].scrollTop = arguments[0].scrollHeight;",
container
);
WebElement panel = driver.findElement(
By.cssSelector(".results-panel")
);
js.executeScript(
"arguments[0].scrollTop += 500;",
panel
);
js.executeScript(
"arguments[0].scrollTop = 0;",
panel
);
js.executeScript(
"arguments[0].scrollTop = arguments[0].scrollHeight;",
panel
);
| Type | JavaScript Example |
|---|---|
| Window vertical scroll | window.scrollBy(0,500) |
| Window top | window.scrollTo(0,0) |
| Window bottom | window.scrollTo(0,document.body.scrollHeight) |
| Container vertical scroll | element.scrollTop |
| Container maximum scroll | element.scrollHeight |
Large tables may be wider than the browser viewport and may require horizontal scrolling.
WebElement tableContainer = driver.findElement(
By.cssSelector(".table-container")
);
js.executeScript(
"arguments[0].scrollLeft = arguments[0].scrollWidth;",
tableContainer
);
js.executeScript("window.scrollBy(500,0);");Long position = (Long) js.executeScript(
"return window.pageYOffset;"
);
System.out.println("Scroll Position: " + position);
Long height = (Long) js.executeScript(
"return document.body.scrollHeight;"
);
System.out.println("Page Height: " + height);
Long viewportHeight = (Long) js.executeScript(
"return window.innerHeight;"
);
System.out.println(
"Viewport Height: " + viewportHeight
);
Complete Page Height
↓
+---------------------------+
| |
| Page Content |
| |
|---------------------------|
| Visible Viewport |
|---------------------------|
| |
| More Content |
| |
+---------------------------+
Page Height > Viewport Height
↓
Scroll
Infinite scrolling is a technique in which additional content is loaded as the user reaches the bottom or near-bottom of a page. Social feeds, product catalogs, news pages, and media applications commonly use this pattern.
Scroll Down
↓
Reach Bottom
↓
Application Requests More Data
↓
New Content Appears
↓
Page Height Changes
↓
Scroll Again
↓
Repeat Until Condition Is Met
JavascriptExecutor js = (JavascriptExecutor) driver;
long previousHeight = (Long) js.executeScript(
"return document.body.scrollHeight;"
);
while (true) {
js.executeScript(
"window.scrollTo(0, document.body.scrollHeight);"
);
Thread.sleep(1000);
long currentHeight = (Long) js.executeScript(
"return document.body.scrollHeight;"
);
if (currentHeight == previousHeight) {
break;
}
previousHeight = currentHeight;
}
This example demonstrates the basic mechanism. In production automation, explicit synchronization based on the application's loading condition is generally preferable to relying only on a fixed sleep.
A practical test should usually stop scrolling when the required content is found instead of scrolling indefinitely.
JavascriptExecutor js = (JavascriptExecutor) driver;
for (int i = 0; i < 20; i++) {
List<WebElement> products =
driver.findElements(By.cssSelector(".product"));
boolean found = false;
for (WebElement product : products) {
if (product.getText().contains("Laptop")) {
found = true;
break;
}
}
if (found) {
break;
}
js.executeScript(
"window.scrollBy(0,700);"
);
}
Lazy loading means that some page resources or content are loaded only when they approach the visible area. Scrolling can trigger the application to load these resources.
js.executeScript(
"window.scrollTo(0, document.body.scrollHeight);"
);
After scrolling, the test should wait for the expected content or state rather than assuming that the content has loaded immediately.
JavaScript can request smooth scrolling in browsers that support the relevant scrolling behavior.
js.executeScript(
"window.scrollTo({top:1000, behavior:'smooth'});"
);
Smooth scrolling is more relevant to visual behavior. Functional automation generally benefits from deterministic scrolling and appropriate synchronization.
WebElement element = driver.findElement(By.id("target"));
js.executeScript(
"arguments[0].scrollIntoView({block:'center'});",
element
);
Assert.assertTrue(element.isDisplayed());
WebElement element = driver.findElement(By.id("target"));
js.executeScript(
"arguments[0].scrollIntoView({block:'center'});",
element
);
Actions actions = new Actions(driver);
actions.moveToElement(element).click().perform();
WebElement element = driver.findElement(
By.cssSelector("#footer")
);
js.executeScript(
"arguments[0].scrollIntoView({block:'center'});",
element
);
WebElement element = driver.findElement(
By.xpath("//button[text()='Submit']")
);
js.executeScript(
"arguments[0].scrollIntoView({block:'center'});",
element
);
WebElement element = driver.findElement(
By.name("address")
);
js.executeScript(
"arguments[0].scrollIntoView({block:'center'});",
element
);
WebElement element = driver.findElement(
By.className("footer")
);
js.executeScript(
"arguments[0].scrollIntoView({block:'center'});",
element
);
WebElement footer = driver.findElement(
By.cssSelector("footer")
);
js.executeScript(
"arguments[0].scrollIntoView({block:'center'});",
footer
);
Assert.assertTrue(
footer.getText().contains("Contact")
);
WebElement link = driver.findElement(
By.linkText("Contact Us")
);
js.executeScript(
"arguments[0].scrollIntoView({block:'center'});",
link
);
link.click();
Assert.assertTrue(
driver.getCurrentUrl().contains("contact")
);
WebElement button = driver.findElement(By.id("dashboard"));
js.executeScript(
"arguments[0].scrollIntoView({block:'center'});",
button
);
button.click();
Assert.assertEquals(
driver.getTitle(),
"Dashboard"
);
ElementClickInterceptedException may occur when another element, popup, overlay, or fixed component is positioned over the target.
Scrolling the target into an appropriate position and waiting for temporary overlays to disappear can often address the problem. JavaScript click should not automatically be used as the first response because the underlying issue may be synchronization or an application-state problem.
Dynamic applications may replace DOM elements while the page is being scrolled. If a previously located element becomes stale, locate the element again.
WebElement element = wait.until(
ExpectedConditions.presenceOfElementLocated(
By.id("target")
)
);
js.executeScript(
"arguments[0].scrollIntoView({block:'center'});",
element
);
If the target element cannot be found, scrolling does not solve the locator problem. Verify the locator, page state, frame context, and timing.
An element can exist in the DOM but still not be ready for interaction. Check visibility, enabled state, overlays, frames, and application synchronization.
If the target element is inside an iframe, Selenium must first switch into the correct frame.
WebElement frame = driver.findElement(
By.id("paymentFrame")
);
driver.switchTo().frame(frame);
WebElement button = driver.findElement(
By.id("submit")
);
js.executeScript(
"arguments[0].scrollIntoView({block:'center'});",
button
);
button.click();
driver.switchTo().defaultContent();
Scrolling applies to the currently active browser window or tab. If the target is in another window, switch to that window first.
driver.switchTo().window(windowHandle);
js.executeScript(
"window.scrollTo(0, document.body.scrollHeight);"
);
Responsive layouts may change element positions based on browser width and height. Therefore, tests should avoid relying on fixed screen coordinates.
driver.manage().window().setSize(
new Dimension(390, 844)
);
After changing the viewport, the test should locate elements again and use element-based scrolling where appropriate.
Headless browser tests still have a viewport and page scrolling behavior even though the browser window is not displayed to the user.
ChromeOptions options = new ChromeOptions();
options.addArguments("--headless=new");
options.addArguments("--window-size=1920,1080");
WebDriver driver = new ChromeDriver(options);
Browser zoom can affect the visual relationship between coordinates and elements. Element-based scrolling is generally more robust than coordinate-based automation.
In a Page Object Model framework, page-specific scrolling can be encapsulated in page methods while generic scrolling functionality can be placed inside a reusable utility class.
public void scrollToSubmitButton() {
WebElement button = driver.findElement(
By.id("submit")
);
JavascriptExecutor js =
(JavascriptExecutor) driver;
js.executeScript(
"arguments[0].scrollIntoView({block:'center'});",
button
);
}
public class ScrollUtils {
private WebDriver driver;
public ScrollUtils(WebDriver driver) {
this.driver = driver;
}
public void scrollDown(int pixels) {
JavascriptExecutor js =
(JavascriptExecutor) driver;
js.executeScript(
"window.scrollBy(0," + pixels + ");"
);
}
public void scrollUp(int pixels) {
JavascriptExecutor js =
(JavascriptExecutor) driver;
js.executeScript(
"window.scrollBy(0,-" + pixels + ");"
);
}
public void scrollToTop() {
JavascriptExecutor js =
(JavascriptExecutor) driver;
js.executeScript(
"window.scrollTo(0,0);"
);
}
public void scrollToBottom() {
JavascriptExecutor js =
(JavascriptExecutor) driver;
js.executeScript(
"window.scrollTo(0,document.body.scrollHeight);"
);
}
public void scrollToElement(WebElement element) {
JavascriptExecutor js =
(JavascriptExecutor) driver;
js.executeScript(
"arguments[0].scrollIntoView({block:'center'});",
element
);
}
}
ScrollUtils scroll = new ScrollUtils(driver);
scroll.scrollDown(500);
scroll.scrollToElement(
driver.findElement(By.id("footer"))
);
scroll.scrollToBottom();
scroll.scrollToTop();
import java.time.Duration;
import org.openqa.selenium.By;
import org.openqa.selenium.JavascriptExecutor;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;
public class ScrollPageExample {
public static void main(String[] args) {
WebDriver driver = new ChromeDriver();
try {
driver.manage().window().maximize();
driver.get("https://example.com");
WebDriverWait wait =
new WebDriverWait(
driver,
Duration.ofSeconds(10)
);
WebElement footer = wait.until(
ExpectedConditions.presenceOfElementLocated(
By.tagName("footer")
)
);
JavascriptExecutor js =
(JavascriptExecutor) driver;
js.executeScript(
"arguments[0].scrollIntoView({block:'center'});",
footer
);
wait.until(
ExpectedConditions.visibilityOf(footer)
);
System.out.println(
"Footer is visible: "
+ footer.isDisplayed()
);
} finally {
driver.quit();
}
}
}
import org.testng.Assert;
import org.testng.annotations.Test;
@Test
public void verifyFooterAfterScrolling() {
WebElement footer = driver.findElement(
By.tagName("footer")
);
JavascriptExecutor js =
(JavascriptExecutor) driver;
js.executeScript(
"arguments[0].scrollIntoView({block:'center'});",
footer
);
Assert.assertTrue(
footer.isDisplayed()
);
}
Suppose an e-commerce product page contains product information at the top, specifications in the middle, customer reviews below, and related products near the bottom.
WebElement reviews = driver.findElement(
By.id("customer-reviews")
);
js.executeScript(
"arguments[0].scrollIntoView({block:'center'});",
reviews
);
Assert.assertTrue(
reviews.isDisplayed()
);
WebElement address = driver.findElement(
By.id("address")
);
js.executeScript(
"arguments[0].scrollIntoView({block:'center'});",
address
);
address.sendKeys("Mumbai");
WebElement submit = driver.findElement(
By.id("submit")
);
js.executeScript(
"arguments[0].scrollIntoView({block:'center'});",
submit
);
submit.click();
WebElement footer = driver.findElement(
By.tagName("footer")
);
js.executeScript(
"arguments[0].scrollIntoView({block:'center'});",
footer
);
List<WebElement> links =
footer.findElements(By.tagName("a"));
System.out.println(
"Footer Links: " + links.size()
);
A dashboard may contain summary cards at the top and reports, charts, tables, and logs farther down the page.
WebElement reportTable = driver.findElement(
By.id("reportTable")
);
js.executeScript(
"arguments[0].scrollIntoView({block:'center'});",
reportTable
);
Assert.assertTrue(
reportTable.isDisplayed()
);
A news website may use infinite scrolling to load additional articles. Selenium can repeatedly scroll, wait for additional articles, inspect the loaded content, and stop when the required article is found.
for (int i = 0; i < 10; i++) {
List<WebElement> articles =
driver.findElements(By.cssSelector("article"));
boolean found = false;
for (WebElement article : articles) {
if (article.getText().contains("Selenium")) {
found = true;
break;
}
}
if (found) {
break;
}
js.executeScript(
"window.scrollBy(0,700);"
);
}
A command such as window.scrollBy(0,5000) may work on one screen size but behave differently on another page or viewport.
When a target element is known, prefer:
js.executeScript(
"arguments[0].scrollIntoView({block:'center'});",
element
);
Fixed sleeps can make tests slower and may still fail when an application takes longer than the chosen delay.
Use explicit waits for application conditions whenever possible.
An element can be visible but still be covered by an overlay, disabled, stale, or not ready for interaction.
WebElement button = wait.until(
ExpectedConditions.elementToBeClickable(
By.id("submit")
)
);
If the page itself does not move when scrolling, inspect the application for an internal scrollable container.
WebElement panel = driver.findElement(
By.cssSelector(".results-panel")
);
js.executeScript(
"arguments[0].scrollTop = arguments[0].scrollHeight;",
panel
);
Coordinate-based scrolling and clicking can become unreliable because browser size, responsive layouts, zoom, operating system settings, and page changes can affect coordinates.
Stable locators and element-based operations are generally easier to maintain.
JavaScriptExecutor is powerful but should not automatically replace Selenium's normal APIs.
For normal interactions, prefer Selenium methods when they work correctly:
element.click();
element.sendKeys("text");
Actions actions = new Actions(driver);
actions.moveToElement(element).click().perform();
When a specific element is the subject of the test, element-based scrolling is usually more maintainable than guessing a pixel amount.
js.executeScript(
"arguments[0].scrollIntoView({block:'center'});",
element
);
WebElement target = wait.until(
ExpectedConditions.visibilityOfElementLocated(
By.id("target")
)
);
Use center alignment or a small scroll offset when fixed headers cover elements after scrolling.
Scrolling is usually an intermediate step. The test should validate the actual expected behavior after scrolling.
js.executeScript(
"arguments[0].scrollIntoView({block:'center'});",
button
);
button.click();
Assert.assertTrue(
driver.getCurrentUrl().contains("dashboard")
);
When scrolling causes the application to refresh or replace DOM elements, locate the required element again instead of assuming the old WebElement reference remains valid.
Common scrolling operations such as scroll top, scroll bottom, scroll by pixels, and scroll to element can be placed in reusable utility classes.
If the target element is inside an iframe, switch to the correct frame before locating and scrolling to the element.
Responsive pages can change layout and scrolling behavior at different browser dimensions. When required, execute the same scrolling scenario at multiple viewport sizes.
Q1. How do you scroll down a webpage in Selenium?
JavascriptExecutor js = (JavascriptExecutor) driver;
js.executeScript("window.scrollBy(0,500);");
Q2. How do you scroll to the bottom of a webpage?
js.executeScript(
"window.scrollTo(0, document.body.scrollHeight);"
);
Q3. How do you scroll to the top?
js.executeScript("window.scrollTo(0,0);");Q4. How do you scroll to a specific WebElement?
js.executeScript(
"arguments[0].scrollIntoView({block:'center'});",
element
);
Q5. What is the difference between scrollBy() and scrollTo()?
scrollBy() moves the viewport relative to its current position, while scrollTo() moves it to an absolute position.
Q6. Can Selenium scroll without JavaScript?
Yes. Selenium's Actions API provides scrolling operations, including scrolling by an amount and scrolling to an element.
Q7. How do you scroll inside a div?
js.executeScript(
"arguments[0].scrollTop = arguments[0].scrollHeight;",
element
);
Q8. What is infinite scrolling?
Infinite scrolling is a page design where additional content is loaded as the user approaches the bottom of the page.
Q9. Does scrolling guarantee that an element is clickable?
No. The element may still be covered, disabled, stale, or affected by application synchronization issues.
Q10. Why is scrollIntoView() useful?
It allows automation to bring a specific element into the viewport without relying on an arbitrary pixel distance.
| Requirement | Code |
|---|---|
| Scroll down | window.scrollBy(0,500) |
| Scroll up | window.scrollBy(0,-500) |
| Scroll top | window.scrollTo(0,0) |
| Scroll bottom | window.scrollTo(0,document.body.scrollHeight) |
| Scroll to element | arguments[0].scrollIntoView() |
| Scroll using Actions | actions.scrollByAmount(0,500).perform() |
| Scroll to element using Actions | actions.scrollToElement(element).perform() |
| Container scroll | arguments[0].scrollTop |
Start Test
↓
Launch Browser
↓
Open Application
↓
Identify Target
↓
Wait for Required Condition
↓
Determine Scroll Type
↓
┌──────────────────────────────┐
│ Window / Element / Container │
└──────────────────────────────┘
↓
Scroll Into Required Position
↓
Verify Visibility / State
↓
Perform Action
↓
Validate Result
↓
Capture Evidence
↓
End Test
JustAcademy's Selenium Automation Testing course provides training resources covering Selenium WebDriver, Java automation, locators, browser automation, TestNG, data-driven testing, Page Object Model, cross-browser testing, automation frameworks, practical projects, and related testing tools.
Page scrolling is an essential Selenium WebDriver skill for testing long, dynamic, responsive, and content-heavy web applications. Selenium provides multiple approaches, including JavaScriptExecutor, Actions scrolling, keyboard actions, element-based scrolling, and scrolling inside individual containers.
For reliable automation, the focus should not be only on moving the page. A good Selenium test identifies the correct target, waits for the required application state, scrolls the target into a suitable viewport position, performs the intended interaction, and validates the expected result.
By practicing scroll-by-pixels, scroll-to-top, scroll-to-bottom, scroll-to-element, container scrolling, horizontal scrolling, infinite scrolling, lazy-loaded content, and scrolling with explicit waits, testers can handle a wide range of real-world Selenium automation scenarios.
